//! 迭代器示例
//!
//! 迭代器是 Rust 中处理元素序列的重要工具，它允许我们以高效和安全的方式遍历集合。
//! Rust 的迭代器是惰性的，这意味着在调用消费迭代器的方法之前，迭代器本身不会执行任何操作。

/// 迭代器基础
///
/// 展示 iter()、iter_mut() 和 into_iter() 三种迭代器的区别
pub fn iterator_basics() {
    println!("=== 迭代器基础 ===");

    let mut vec = vec![1, 2, 3];

    // iter() - 生成不可变引用的迭代器 (&T)
    println!("使用 iter() 遍历:");
    for item in vec.iter() {
        println!("不可变引用: {}", item);
    }
    // vec 仍然可以使用，因为 iter() 只是借用
    println!("原向量: {:?}", vec);

    // iter_mut() - 生成可变引用的迭代器 (&mut T)
    println!("使用 iter_mut() 修改元素:");
    for item in vec.iter_mut() {
        *item *= 2;
    }
    println!("修改后的向量: {:?}", vec);

    // into_iter() - 生成获取所有权的迭代器 (T)
    println!("使用 into_iter() 获取所有权:");
    for item in vec.into_iter() {
        println!("拥有所有权的元素: {}", item);
    }
    // vec 在这里已经无法使用了，因为所有权已经被转移
    // println!("{:?}", vec); // 这行会编译错误
}

/// 迭代器适配器
///
/// 展示常用的迭代器适配器，如 map、filter 等
pub fn iterator_adapters() {
    println!("\n=== 迭代器适配器 ===");

    let numbers = vec![1, 2, 3, 4, 5];

    // map - 对每个元素应用函数
    let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();
    println!("原数字: {:?}", numbers);
    println!("翻倍后: {:?}", doubled);

    // filter - 过滤满足条件的元素
    let evens: Vec<&i32> = numbers.iter().filter(|&x| x % 2 == 0).collect();
    println!("偶数: {:?}", evens);

    // fold - 累积计算

    // 拼接字符串
    let words = vec!["Hello", " ", "world", "!"];
    let sentence = words.iter().fold(String::new(), |acc, s| acc + s);
    println!("拼接结果: {}", sentence);

    // 找出最长字符串
    let longest = words
        .iter()
        .fold("", |acc, &s| if s.len() > acc.len() { s } else { acc });
    println!("最长字符串: {}", longest);

    // chain - 连接两个迭代器
    let vec1 = vec![1, 2, 3];
    let vec2 = vec![4, 5, 6];
    let chained: Vec<i32> = vec1.iter().chain(vec2.iter()).cloned().collect();
    println!("连接结果: {:?}", chained);
}

/// 消费迭代器的方法
///
/// 展示消费迭代器并产生结果的方法
pub fn consuming_adapters() {
    println!("\n=== 消费适配器 ===");

    let numbers = vec![1, 2, 3, 4, 5];

    // collect - 收集迭代器元素到集合中
    let squares: Vec<i32> = numbers.iter().map(|x| x * x).collect();
    println!("平方: {:?}", squares);

    // sum - 计算元素总和
    let sum: i32 = numbers.iter().sum();
    println!("总和: {}", sum);

    // max/min - 找到最大/最小值
    let max = numbers.iter().max();
    let min = numbers.iter().min();
    println!("最大值: {:?}", max);
    println!("最小值: {:?}", min);

    // any/all - 检查是否有一些/所有元素满足条件
    let has_even = numbers.iter().any(|&x| x % 2 == 0);
    let all_positive = numbers.iter().all(|&x| x > 0);
    println!("是否有偶数: {}", has_even);
    println!("是否都是正数: {}", all_positive);
}

/// 自定义迭代器
///
/// 展示如何实现 Iterator trait 创建自定义迭代器
pub fn custom_iterator() {
    println!("\n=== 自定义迭代器 ===");

    struct Counter {
        current: u32,
        max: u32,
    }

    impl Counter {
        fn new(max: u32) -> Counter {
            Counter { current: 0, max }
        }
    }

    impl Iterator for Counter {
        type Item = u32;

        fn next(&mut self) -> Option<Self::Item> {
            if self.current < self.max {
                self.current += 1;
                Some(self.current - 1)
            } else {
                None
            }
        }
    }

    let counter = Counter::new(5);
    println!("自定义计数器:");
    for num in counter {
        println!("计数: {}", num);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_iterator_basics() {
        iterator_basics();
    }

    #[test]
    fn test_iterator_adapters() {
        iterator_adapters();
    }

    #[test]
    fn test_consuming_adapters() {
        consuming_adapters();
    }

    #[test]
    fn test_custom_iterator() {
        custom_iterator();
    }
}
